FastAPI మిడిల్‌వేర్‌ను మొదట నుండి నేర్చుకోండి. ఈ లోతైన గైడ్ కస్టమ్ మిడిల్‌వేర్, ప్రమాణీకరణ, లాగింగ్, లోపం నిర్వహణ మరియు బలమైన APIలను నిర్మించడానికి ఉత్తమ పద్ధతులను కవర్ చేస్తుంది.
Python FastAPI Middleware: అభ్యర్థన మరియు ప్రతిస్పందన ప్రాసెసింగ్ కోసం ఒక సమగ్ర గైడ్
ఆధునిక వెబ్ అభివృద్ధి ప్రపంచంలో, పనితీరు, భద్రత మరియు నిర్వహణ చాలా ముఖ్యమైనవి. Python యొక్క FastAPI ఫ్రేమ్‌వర్క్ దాని అద్భుతమైన వేగం మరియు డెవలపర్-స్నేహపూర్వక ఫీచర్ల కోసం వేగంగా ప్రజాదరణ పొందింది. దాని అత్యంత శక్తివంతమైన మరియు కొన్నిసార్లు తప్పుగా అర్థం చేసుకోబడిన లక్షణాలలో ఒకటి మిడిల్‌వేర్. మిడిల్‌వేర్ అభ్యర్థన దాని గమ్యస్థానానికి చేరుకునే ముందు లేదా ప్రతిస్పందనను క్లయింట్‌కు తిరిగి పంపే ముందు కోడ్‌ను అమలు చేయడానికి, డేటాను మార్చడానికి మరియు నియమాలను అమలు చేయడానికి డెవలపర్‌లను అనుమతించడం ద్వారా అభ్యర్థన మరియు ప్రతిస్పందన ప్రాసెసింగ్ గొలుసులో ఒక కీలకమైన లింక్‌గా పనిచేస్తుంది.
ఈ సమగ్ర గైడ్ FastAPI తో మొదలవుతున్న వారి నుండి లోతైన అవగాహనను కోరుకునే అనుభవజ్ఞులైన నిపుణుల వరకు, డెవలపర్‌ల ప్రపంచవ్యాప్త శ్రేణి కోసం రూపొందించబడింది. మేము మిడిల్‌వేర్ యొక్క ప్రధాన భావనలను అన్వేషిస్తాము, కస్టమ్ పరిష్కారాలను ఎలా రూపొందించాలో ప్రదర్శిస్తాము మరియు ఆచరణాత్మక, వాస్తవ-ప్రపంచ ఉపయోగ సందర్భాలను పరిశీలిస్తాము. చివరికి, మీరు మరింత బలమైన, సురక్షితమైన మరియు సమర్థవంతమైన APIలను రూపొందించడానికి మిడిల్‌వేర్‌ను ఉపయోగించుకోవడానికి సిద్ధంగా ఉంటారు.
వెబ్ ఫ్రేమ్‌వర్క్‌ల సందర్భంలో మిడిల్‌వేర్ అంటే ఏమిటి?
కోడ్‌లోకి ప్రవేశించే ముందు, ఈ భావనను అర్థం చేసుకోవడం చాలా అవసరం. మీ అప్లికేషన్ యొక్క అభ్యర్థన-ప్రతిస్పందన చక్రాన్ని ఒక పైప్‌లైన్ లేదా అసెంబ్లీ లైన్‌గా ఊహించుకోండి. ఒక క్లయింట్ మీ APIకి అభ్యర్థనను పంపినప్పుడు, అది తక్షణమే మీ ఎండ్‌పాయింట్ లాజిక్‌ను తాకదు. బదులుగా, ఇది అనేక ప్రాసెసింగ్ దశల ద్వారా ప్రయాణిస్తుంది. అదేవిధంగా, మీ ఎండ్‌పాయింట్ ప్రతిస్పందనను ఉత్పత్తి చేసినప్పుడు, అది క్లయింట్‌కు చేరుకోవడానికి ముందు ఈ దశల ద్వారా తిరిగి ప్రయాణిస్తుంది. మిడిల్‌వేర్ భాగాలు పైప్‌లైన్‌లో ఉన్న ఈ దశలు.
ఒక ప్రసిద్ధ పోలిక ఉల్లిపాయ నమూనా. ఉల్లిపాయ యొక్క ప్రధాన భాగం మీ అప్లికేషన్ యొక్క వ్యాపార తర్కం (ఎండ్‌పాయింట్). కోర్‌ను చుట్టుముట్టే ఉల్లిపాయ యొక్క ప్రతి పొర మిడిల్‌వేర్ ముక్క. కోర్‌కు చేరుకోవడానికి ఒక అభ్యర్థన ప్రతి బాహ్య పొర ద్వారా వెళ్ళాలి మరియు ప్రతిస్పందన అదే పొరల ద్వారా తిరిగి ప్రయాణిస్తుంది. ప్రతి పొర లోపలికి వెళ్లేటప్పుడు అభ్యర్థనను పరిశీలించవచ్చు మరియు సవరించవచ్చు మరియు బయటికి వెళ్లేటప్పుడు ప్రతిస్పందనను సవరించవచ్చు.
సాధారణంగా, మిడిల్‌వేర్ అనేది అభ్యర్థన వస్తువు, ప్రతిస్పందన వస్తువు మరియు అప్లికేషన్ యొక్క అభ్యర్థన-ప్రతిస్పందన చక్రంలో తదుపరి మిడిల్‌వేర్‌కు ప్రాప్యతను కలిగి ఉన్న ఒక ఫంక్షన్ లేదా క్లాస్. దీని ప్రాథమిక ఉద్దేశాలు ఉన్నాయి:
- కోడ్‌ను అమలు చేయడం: ప్రతి ఇన్‌కమింగ్ అభ్యర్థన కోసం లాగింగ్ లేదా పనితీరు పర్యవేక్షణ వంటి చర్యలను నిర్వహించండి.
- అభ్యర్థన మరియు ప్రతిస్పందనను సవరించడం: హెడర్‌లను జోడించండి, ప్రతిస్పందన బాడీలను కుదించండి లేదా డేటా ఫార్మాట్‌లను మార్చండి.
- చక్రం యొక్క షార్ట్-సర్క్యూటింగ్: అభ్యర్థన-ప్రతిస్పందన చక్రాన్ని ప్రారంభంలోనే ముగించండి. ఉదాహరణకు, ప్రమాణీకరణ మిడిల్‌వేర్, అసురక్షిత అభ్యర్థనను ఉద్దేశించిన ఎండ్‌పాయింట్‌కు చేరుకునే ముందు బ్లాక్ చేయవచ్చు.
- ప్రపంచ సమస్యలను నిర్వహించడం: లోపం నిర్వహణ, CORS (క్రాస్-ఆరిజిన్ రిసోర్స్ షేరింగ్) మరియు సెషన్ నిర్వహణ వంటి క్రాస్-కట్టింగ్ సమస్యలను కేంద్రీకృత స్థలంలో నిర్వహించండి.
FastAPI Starlette టూల్‌కిట్‌పై నిర్మించబడింది, ఇది ASGI (అసమకాలిక సర్వర్ గేట్‌వే ఇంటర్‌ఫేస్) ప్రమాణం యొక్క బలమైన అమలును అందిస్తుంది. మిడిల్‌వేర్ ASGI లో ఒక ప్రాథమిక భావన, ఇది FastAPI పర్యావరణ వ్యవస్థలో మొదటి-తరగతి పౌరుడిగా చేస్తుంది.
సరళమైన రూపం: డెకరేటర్‌తో FastAPI మిడిల్‌వేర్
FastAPI @app.middleware("http") డెకరేటర్‌ని ఉపయోగించి మిడిల్‌వేర్‌ను జోడించడానికి ఒక సరళమైన మార్గాన్ని అందిస్తుంది. ప్రతి HTTP అభ్యర్థన కోసం అమలు చేయాల్సిన సాధారణ, స్వీయ-నియంత్రిత లాజిక్ కోసం ఇది చాలా అనుకూలంగా ఉంటుంది.
క్లాసిక్ ఉదాహరణను సృష్టిద్దాం: ప్రతి అభ్యర్థన కోసం ప్రాసెసింగ్ సమయాన్ని లెక్కించడానికి మరియు దానిని ప్రతిస్పందన హెడర్‌లకు జోడించడానికి ఒక మిడిల్‌వేర్. ఇది పనితీరు పర్యవేక్షణ కోసం చాలా ఉపయోగకరంగా ఉంటుంది.
ఉదాహరణ: ప్రాసెస్-టైమ్ మిడిల్‌వేర్
ముందుగా, మీరు FastAPI మరియు Uvicorn వంటి ASGI సర్వర్‌ను ఇన్‌స్టాల్ చేశారని నిర్ధారించుకోండి:
pip install fastapi uvicorn
ఇప్పుడు, main.py అనే ఫైల్‌లో కోడ్‌ను వ్రాద్దాం:
import time
from fastapi import FastAPI, Request
app = FastAPI()
# మిడిల్‌వేర్ ఫంక్షన్‌ను నిర్వచించండి
@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
# అభ్యర్థన వచ్చినప్పుడు ప్రారంభ సమయాన్ని రికార్డ్ చేయండి
start_time = time.time()
# తదుపరి మిడిల్‌వేర్‌కు లేదా ఎండ్‌పాయింట్‌కు కొనసాగండి
response = await call_next(request)
# ప్రాసెసింగ్ సమయాన్ని లెక్కించండి
process_time = time.time() - start_time
# ప్రతిస్పందనకు అనుకూల హెడర్‌ను జోడించండి
response.headers["X-Process-Time"] = str(process_time)
return response
@app.get("/")
async def root():
# కొంత పనిని అనుకరించండి
time.sleep(0.5)
return {"message": "Hello, World!"}
ఈ అప్లికేషన్‌ను అమలు చేయడానికి, ఈ కమాండ్ ఉపయోగించండి:
uvicorn main:app --reload
ఇప్పుడు, మీరు cURL లేదా పోస్ట్‌మాన్ వంటి API క్లయింట్ వంటి సాధనాన్ని ఉపయోగించి http://127.0.0.1:8000కి అభ్యర్థనను పంపినట్లయితే, మీరు ప్రతిస్పందనలో X-Process-Time అనే కొత్త హెడర్‌ను చూస్తారు, సుమారుగా 0.5 సెకన్ల విలువతో.
కోడ్‌ను విచ్ఛిన్నం చేయడం:
@app.middleware("http"): ఈ డెకరేటర్ మా ఫంక్షన్‌ను HTTP మిడిల్‌వేర్‌గా నమోదు చేస్తుంది.async def add_process_time_header(request: Request, call_next):: మిడిల్‌వేర్ ఫంక్షన్ అసమకాలికంగా ఉండాలి. ఇది ఇన్‌కమింగ్Requestవస్తువును మరియు ప్రత్యేక ఫంక్షన్,call_nextను స్వీకరిస్తుంది.response = await call_next(request): ఇది చాలా కీలకమైన లైన్.call_nextఅభ్యర్థనను పైప్‌లైన్‌లోని తదుపరి దశకు (మరొక మిడిల్‌వేర్ లేదా వాస్తవ మార్గ ఆపరేషన్) పంపుతుంది. మీరు ఖచ్చితంగా ఈ కాల్‌కు `await` చేయాలి. ఫలితం ఎండ్‌పాయింట్ ద్వారా ఉత్పత్తి చేయబడినResponseవస్తువు.response.headers[...] = ...: ప్రతిస్పందనను ఎండ్‌పాయింట్ నుండి స్వీకరించిన తర్వాత, మేము దానిని సవరించవచ్చు, ఈ సందర్భంలో, అనుకూల హెడర్‌ను జోడించడం ద్వారా.return response: చివరగా, సవరించిన ప్రతిస్పందన క్లయింట్‌కు పంపడానికి తిరిగి ఇవ్వబడుతుంది.
తరగతులతో మీ స్వంత అనుకూల మిడిల్‌వేర్‌ను రూపొందించడం
డెకరేటర్ విధానం సరళమైనది అయితే, మరింత క్లిష్టమైన దృశ్యాలలో ఇది పరిమితం చేయవచ్చు, ప్రత్యేకించి మీ మిడిల్‌వేర్‌కు కాన్ఫిగరేషన్ అవసరమైనప్పుడు లేదా కొన్ని అంతర్గత స్థితిని నిర్వహించాల్సిన అవసరం ఉన్నప్పుడు. ఈ సందర్భాలలో, FastAPI (Starlette ద్వారా) BaseHTTPMiddlewareని ఉపయోగించి తరగతి-ఆధారిత మిడిల్‌వేర్‌కు మద్దతు ఇస్తుంది.
తరగతి-ఆధారిత విధానం మంచి నిర్మాణాన్ని అందిస్తుంది, దాని కన్స్ట్రక్టర్‌లో డిపెండెన్సీ ఇంజెక్షన్ చేయడానికి అనుమతిస్తుంది మరియు క్లిష్టమైన లాజిక్ కోసం సాధారణంగా మరింత నిర్వహించదగినది. ప్రధాన తర్కం అసమకాలిక dispatch పద్ధతిలో ఉంటుంది.
ఉదాహరణ: క్లాస్-ఆధారిత API కీ ప్రమాణీకరణ మిడిల్‌వేర్
మా APIని సురక్షితం చేసే మరింత ఆచరణాత్మక మిడిల్‌వేర్‌ను నిర్మిద్దాం. ఇది నిర్దిష్ట హెడర్, X-API-Key కోసం తనిఖీ చేస్తుంది మరియు కీ లేనట్లయితే లేదా చెల్లనిదైతే, అది వెంటనే 403 Forbidden లోపం ప్రతిస్పందనను అందిస్తుంది. ఇది అభ్యర్థనను "షార్ట్-సర్క్యూటింగ్" చేయడానికి ఒక ఉదాహరణ.
main.pyలో:
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from starlette.responses import Response
# చెల్లుబాటు అయ్యే API కీ జాబితా. నిజమైన అప్లికేషన్‌లో, ఇది డేటాబేస్ లేదా సురక్షితమైన వాల్ట్ నుండి వస్తుంది.
VALID_API_KEYS = ["my-super-secret-key", "another-valid-key"]
class APIKeyMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
api_key = request.headers.get("X-API-Key")
if api_key not in VALID_API_KEYS:
# అభ్యర్థనను షార్ట్-సర్క్యూట్ చేసి, లోపం ప్రతిస్పందనను అందించండి
return JSONResponse(
status_code=403,
content={"detail": "Forbidden: Invalid or missing API Key"}
)
# కీ చెల్లుబాటయితే, అభ్యర్థనతో కొనసాగండి
response = await call_next(request)
return response
app = FastAPI()
# అప్లికేషన్‌కు మిడిల్‌వేర్‌ను జోడించండి
app.add_middleware(APIKeyMiddleware)
@app.get("/")
async def root():
return {"message": "Welcome to the secure zone!"}
ఇప్పుడు, మీరు ఈ అప్లికేషన్‌ను అమలు చేసినప్పుడు:
X-API-Keyహెడర్ లేకుండా (లేదా తప్పు విలువతో) అభ్యర్థన 403 స్థితి కోడ్‌ను మరియు JSON లోపం సందేశాన్ని అందుకుంటుంది.X-API-Key: my-super-secret-keyహెడర్‌తో అభ్యర్థన విజయవంతమవుతుంది మరియు 200 OK ప్రతిస్పందనను అందుకుంటుంది.
ఈ నమూనా చాలా శక్తివంతమైనది. / వద్ద ఎండ్‌పాయింట్ కోడ్ API కీ ధ్రువీకరణ గురించి ఏమీ తెలుసుకోవలసిన అవసరం లేదు; ఆ ఆందోళన మిడిల్‌వేర్ లేయర్‌లోకి పూర్తిగా వేరు చేయబడింది.
మిడిల్‌వేర్ కోసం సాధారణ మరియు శక్తివంతమైన ఉపయోగ సందర్భాలు
మిడిల్‌వేర్ క్రాస్-కట్టింగ్ సమస్యలను నిర్వహించడానికి సరైన సాధనం. అత్యంత సాధారణమైన మరియు ప్రభావవంతమైన ఉపయోగ సందర్భాలను అన్వేషిద్దాం.
1. కేంద్రీకృత లాగింగ్
ఉత్పత్తి అనువర్తనాల కోసం సమగ్ర లాగింగ్ తప్పనిసరి. ప్రతి అభ్యర్థన మరియు దాని సంబంధిత ప్రతిస్పందన గురించి క్లిష్టమైన సమాచారాన్ని మీరు లాగ్ చేసే ఒకే బిందువును మిడిల్‌వేర్ మిమ్మల్ని అనుమతిస్తుంది.
ఉదాహరణ లాగింగ్ మిడిల్‌వేర్:
import logging
from fastapi import FastAPI, Request
import time
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
app = FastAPI()
@app.middleware("http")
async def logging_middleware(request: Request, call_next):
start_time = time.time()
# అభ్యర్థన వివరాలను లాగ్ చేయండి
logger.info(f"Incoming request: {request.method} {request.url.path}")
response = await call_next(request)
process_time = time.time() - start_time
# ప్రతిస్పందన వివరాలను లాగ్ చేయండి
logger.info(f"Response status: {response.status_code} | Process time: {process_time:.4f}s")
return response
ఈ మిడిల్‌వేర్ లోపలికి వెళ్ళేటప్పుడు అభ్యర్థన పద్ధతి మరియు మార్గాన్ని లాగ్ చేస్తుంది మరియు బయటికి వెళ్ళేటప్పుడు ప్రతిస్పందన స్థితి కోడ్ మరియు మొత్తం ప్రాసెసింగ్ సమయాన్ని లాగ్ చేస్తుంది. ఇది మీ అప్లికేషన్ ట్రాఫిక్‌లో అమూల్యమైన దృశ్యమానతను అందిస్తుంది.
2. గ్లోబల్ లోపం నిర్వహణ
డిఫాల్ట్‌గా, మీ కోడ్‌లో నిర్వహించబడని మినహాయింపు 500 అంతర్గత సర్వర్ లోపానికి దారి తీస్తుంది, ఇది క్లయింట్‌కు స్టాక్ జాడలు మరియు అమలు వివరాలను బహిర్గతం చేస్తుంది. గ్లోబల్ లోపం నిర్వహణ మిడిల్‌వేర్ అన్ని మినహాయింపులను పట్టుకోగలదు, వాటిని అంతర్గత సమీక్ష కోసం లాగ్ చేయగలదు మరియు ప్రామాణికం చేసిన, యూజర్-స్నేహపూర్వక లోపం ప్రతిస్పందనను అందిస్తుంది.
ఉదాహరణ లోపం నిర్వహణ మిడిల్‌వేర్:
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import logging
logger = logging.getLogger(__name__)
app = FastAPI()
@app.middleware("http")
async def error_handling_middleware(request: Request, call_next):
try:
return await call_next(request)
except Exception as e:
logger.error(f"An unhandled error occurred: {e}", exc_info=True)
return JSONResponse(
status_code=500,
content={"detail": "An internal server error occurred. Please try again later."}
)
@app.get("/error")
async def cause_error():
return 1 / 0 # ఇది ZeroDivisionErrorని పెంచుతుంది
ఈ మిడిల్‌వేర్‌తో, /errorకి అభ్యర్థన ఇకపై సర్వర్‌ను క్రాష్ చేయదు లేదా స్టాక్ జాడను బహిర్గతం చేయదు. బదులుగా, అది శుభ్రమైన JSON బాడీతో 500 స్థితి కోడ్‌ను అందిస్తుంది, డెవలపర్‌లు పరిశోధించడానికి పూర్తి లోపం సర్వర్-సైడ్‌లో లాగ్ చేయబడుతుంది.
3. CORS (క్రాస్-ఆరిజిన్ రిసోర్స్ షేరింగ్)
మీ ఫ్రంటెండ్ అప్లికేషన్ మీ FastAPI బ్యాకెండ్ కంటే భిన్నమైన డొమైన్, ప్రోటోకాల్ లేదా పోర్ట్ నుండి అందించబడితే, బ్రౌజర్‌లు అదే-ఆరిజిన్ పాలసీ కారణంగా అభ్యర్థనలను బ్లాక్ చేస్తాయి. CORS ఈ పాలసీని సడలించే విధానం. FastAPI ఈ ప్రయోజనం కోసం ప్రత్యేకమైన, అత్యంత కాన్ఫిగర్ చేయదగిన `CORSMiddleware`ని అందిస్తుంది.
ఉదాహరణ CORS కాన్ఫిగరేషన్:
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
app = FastAPI()
# అనుమతించబడిన మూలాల జాబితాను నిర్వచించండి. పబ్లిక్ APIల కోసం "*" ఉపయోగించండి, కానీ మంచి భద్రత కోసం నిర్దిష్టంగా ఉండండి.
origins = [
"http://localhost:3000",
"https://my-production-frontend.com",
]
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True, # క్రాస్-ఆరిజిన్ అభ్యర్థనలలో కుకీలను చేర్చడానికి అనుమతించండి
allow_methods=["*"], # అన్ని ప్రామాణిక HTTP పద్ధతులను అనుమతించండి
allow_headers=["*"], # అన్ని హెడర్‌లను అనుమతించండి
)
విడదీయబడిన ఫ్రంటెండ్‌తో ఏదైనా ప్రాజెక్ట్‌కు మీరు జోడించే మొదటి మిడిల్‌వేర్‌లలో ఇది ఒకటి, ఇది ఒకే, కేంద్ర స్థానం నుండి క్రాస్-ఆరిజిన్ పాలసీలను నిర్వహించడం సులభం చేస్తుంది.
4. GZip కంప్రెషన్
HTTP ప్రతిస్పందనలను కుదించడం వాటి పరిమాణాన్ని గణనీయంగా తగ్గిస్తుంది, ఇది క్లయింట్‌లకు వేగవంతమైన లోడ్ సమయాలకు మరియు తక్కువ బ్యాండ్‌విడ్త్ ఖర్చులకు దారి తీస్తుంది. FastAPI దీన్ని స్వయంచాలకంగా నిర్వహించడానికి `GZipMiddleware`ని కలిగి ఉంది.
ఉదాహరణ GZip మిడిల్‌వేర్:
from fastapi import FastAPI
from fastapi.middleware.gzip import GZipMiddleware
app = FastAPI()
# GZip మిడిల్‌వేర్‌ను జోడించండి. మీరు కుదింపు కోసం కనిష్ట పరిమాణాన్ని సెట్ చేయవచ్చు.
app.add_middleware(GZipMiddleware, minimum_size=1000)
@app.get("/")
async def root():
# ఈ ప్రతిస్పందన చిన్నది మరియు gzipped కాదు.
return {"message": "Hello World"}
@app.get("/large-data")
async def large_data():
# ఈ పెద్ద ప్రతిస్పందన మిడిల్‌వేర్ ద్వారా స్వయంచాలకంగా gzipped అవుతుంది.
return {"data": "a_very_long_string..." * 1000}
ఈ మిడిల్‌వేర్‌తో, క్లయింట్ GZip ఎన్‌కోడింగ్‌ను అంగీకరిస్తే (వాస్తవానికి అన్ని ఆధునిక బ్రౌజర్‌లు మరియు క్లయింట్‌లు చేస్తారు) 1000 బైట్‌ల కంటే పెద్ద ఏదైనా ప్రతిస్పందన కుదించబడుతుంది.
అధునాతన భావనలు మరియు ఉత్తమ పద్ధతులు
మీరు మిడిల్‌వేర్‌తో మరింత ప్రావీణ్యం సంపాదించినప్పుడు, శుభ్రమైన, సమర్థవంతమైన మరియు ఊహించదగిన కోడ్‌ను వ్రాయడానికి కొన్ని సూక్ష్మ నైపుణ్యాలను మరియు ఉత్తమ పద్ధతులను అర్థం చేసుకోవడం ముఖ్యం.
1. మిడిల్‌వేర్ ఆర్డర్ ముఖ్యం!
గుర్తుంచుకోవలసిన అత్యంత కీలకమైన నియమం ఇదే. మిడిల్‌వేర్ అప్లికేషన్‌కు జోడించిన క్రమంలో ప్రాసెస్ చేయబడుతుంది. జోడించిన మొదటి మిడిల్‌వేర్ "ఉల్లిపాయ" యొక్క బయటి పొర.
ఈ సెటప్‌ను పరిగణించండి:
app.add_middleware(ErrorHandlingMiddleware) # బయట
app.add_middleware(LoggingMiddleware)
app.add_middleware(AuthenticationMiddleware) # లోపల
ఒక అభ్యర్థన ప్రవాహం ఇలా ఉంటుంది:
ErrorHandlingMiddlewareఅభ్యర్థనను అందుకుంటుంది. ఇది దాని `call_next`ని `try...except` బ్లాక్‌లో చుట్టిస్తుంది.- ఇది `next`ని పిలుస్తుంది, అభ్యర్థనను
LoggingMiddlewareకి పంపుతుంది. LoggingMiddlewareఅభ్యర్థనను అందుకుంటుంది, లాగ్ చేస్తుంది మరియు `next`ని పిలుస్తుంది.AuthenticationMiddlewareఅభ్యర్థనను అందుకుంటుంది, ఆధారాలను ధ్రువీకరిస్తుంది మరియు `next`ని పిలుస్తుంది.- అభ్యర్థన చివరకు ఎండ్‌పాయింట్‌కు చేరుకుంటుంది.
- ఎండ్‌పాయింట్ ఒక ప్రతిస్పందనను అందిస్తుంది.
AuthenticationMiddlewareప్రతిస్పందనను అందుకుంటుంది మరియు దానిని పైకి పంపుతుంది.LoggingMiddlewareప్రతిస్పందనను అందుకుంటుంది, లాగ్ చేస్తుంది మరియు దానిని పైకి పంపుతుంది.ErrorHandlingMiddlewareతుది ప్రతిస్పందనను అందుకుంటుంది మరియు దానిని క్లయింట్‌కు అందిస్తుంది.
ఈ క్రమం తార్కికం: లోపం హ్యాండ్లర్ బయట ఉంది, కాబట్టి ఇది ఇతర మిడిల్‌వేర్‌తో సహా ఏదైనా తదుపరి లేయర్ నుండి లోపాలను గుర్తించగలదు. ప్రమాణీకరణ లేయర్ లోపల లోతుగా ఉంది, కాబట్టి మేము ఇప్పటికే తిరస్కరించబడే అభ్యర్థనలను లాగింగ్ చేయడానికి లేదా ప్రాసెస్ చేయడానికి ఇబ్బంది పడము.
2. request.stateతో డేటాను పంపడం
కొన్నిసార్లు, ఒక మిడిల్‌వేర్ ఎండ్‌పాయింట్‌కు సమాచారాన్ని పంపాలి. ఉదాహరణకు, ప్రమాణీకరణ మిడిల్‌వేర్ JWTని డీకోడ్ చేయవచ్చు మరియు వినియోగదారు యొక్క IDని సంగ్రహించవచ్చు. ఈ వినియోగదారు IDని మార్గ ఆపరేషన్ ఫంక్షన్‌కు ఇది ఎలా అందుబాటులో ఉంచగలదు?
తప్పు మార్గం అభ్యర్థన వస్తువును నేరుగా మార్చడం. సరైన మార్గం request.state వస్తువును ఉపయోగించడం. ఇది ఖచ్చితమైన ప్రయోజనం కోసం అందించబడిన సాధారణ, ఖాళీ వస్తువు.
ఉదాహరణ: మిడిల్‌వేర్ నుండి వినియోగదారు డేటాను పంపడం
# మీ ప్రమాణీకరణ మిడిల్‌వేర్ యొక్క డిస్పాచ్ పద్ధతిలో:
# ... టోకెన్‌ను ధ్రువీకరించిన తర్వాత మరియు వినియోగదారుని డీకోడ్ చేసిన తర్వాత ...
user_data = {"id": 123, "username": "global_dev"}
request.state.user = user_data
response = await call_next(request)
# మీ ఎండ్‌పాయింట్‌లో:
@app.get("/profile")
async def get_user_profile(request: Request):
current_user = request.state.user
return {"profile_for": current_user}
ఇది తర్కాన్ని శుభ్రంగా ఉంచుతుంది మరియు `Request` వస్తువు యొక్క పేరు స్థలాన్ని కలుషితం చేయకుండా ఉంచుతుంది.
3. పనితీరు పరిశీలనలు
మిడిల్‌వేర్ శక్తివంతమైనది అయితే, ప్రతి లేయర్ కొద్ది మొత్తంలో ఓవర్‌హెడ్‌ను జోడిస్తుంది. అధిక-పనితీరు గల అప్లికేషన్‌ల కోసం, ఈ అంశాలను గుర్తుంచుకోండి:
- దీన్ని లీన్‌గా ఉంచండి: మిడిల్‌వేర్ లాజిక్ వీలైనంత వేగంగా మరియు సమర్థవంతంగా ఉండాలి.
- అసమకాలికంగా ఉండండి: మీ మిడిల్‌వేర్‌కు I/O కార్యకలాపాలు (డేటాబేస్ చెక్ వంటివి) నిర్వహించవలసి వస్తే, సర్వర్ యొక్క ఈవెంట్ లూప్‌ను బ్లాక్ చేయకుండా ఉండటానికి ఇది పూర్తిగా `async` అని నిర్ధారించుకోండి.
- ఉద్దేశ్యంతో ఉపయోగించండి: మీకు అవసరం లేని మిడిల్‌వేర్‌ను జోడించవద్దు. ప్రతి ఒక్కటి కాల్ స్టాక్ లోతు మరియు ప్రాసెసింగ్ సమయానికి జోడిస్తుంది.
4. మీ మిడిల్‌వేర్‌ను పరీక్షించడం
మిడిల్‌వేర్ మీ అప్లికేషన్ యొక్క లాజిక్‌లో ఒక కీలకమైన భాగం మరియు పూర్తిగా పరీక్షించబడాలి. FastAPI యొక్క `TestClient` దీన్ని సూటిగా చేస్తుంది. మీరు అవసరమైన షరతులు లేకుండా (ఉదా. చెల్లుబాటు అయ్యే API కీతో మరియు లేకుండా) అభ్యర్థనలను పంపే పరీక్షలను వ్రాయవచ్చు మరియు మిడిల్‌వేర్ ఆశించిన విధంగా ప్రవర్తిస్తుందని పేర్కొనవచ్చు.
APIKeyMiddleware కోసం ఉదాహరణ పరీక్ష:
from fastapi.testclient import TestClient
from .main import app # మీ FastAPI యాప్‌ను దిగుమతి చేయండి
client = TestClient(app)
def test_request_without_api_key_is_forbidden():
response = client.get("/")
assert response.status_code == 403
assert response.json() == {"detail": "Forbidden: Invalid or missing API Key"}
def test_request_with_valid_api_key_is_successful():
headers = {"X-API-Key": "my-super-secret-key"}
response = client.get("/", headers=headers)
assert response.status_code == 200
assert response.json() == {"message": "Welcome to the secure zone!"}
ముగింపు
FastAPI మిడిల్‌వేర్ అనేది ఆధునిక వెబ్ APIలను నిర్మించే ఏ డెవలపర్ అయినా ఉపయోగించాల్సిన ఒక ప్రాథమిక మరియు శక్తివంతమైన సాధనం. ఇది మీ ప్రధాన వ్యాపార తర్కం నుండి వాటిని వేరు చేస్తూ, క్రాస్-కట్టింగ్ సమస్యలను నిర్వహించడానికి ఒక సొగసైన మరియు పునర్వినియోగ మార్గాన్ని అందిస్తుంది. ప్రతి అభ్యర్థన మరియు ప్రతిస్పందనను అడ్డగించడం మరియు ప్రాసెస్ చేయడం ద్వారా, మిడిల్‌వేర్ మీకు బలమైన లాగింగ్, కేంద్రీకృత లోపం నిర్వహణ, కఠినమైన భద్రతా విధానాలు మరియు కుదింపు వంటి పనితీరు మెరుగుదలలను అమలు చేయడానికి అనుమతిస్తుంది.
సాధారణ @app.middleware("http") డెకరేటర్ నుండి అధునాతనమైన, తరగతి-ఆధారిత పరిష్కారాల వరకు, మీ అవసరాలకు సరైన విధానాన్ని ఎంచుకోవడానికి మీకు సౌలభ్యం ఉంది. మిడిల్‌వేర్ ఆర్డరింగ్ మరియు స్టేట్ మేనేజ్‌మెంట్ వంటి ప్రధాన భావనలు, సాధారణ ఉపయోగ సందర్భాలు మరియు ఉత్తమ పద్ధతులను అర్థం చేసుకోవడం ద్వారా, మీరు మరింత శుభ్రమైన, సురక్షితమైన మరియు అత్యంత నిర్వహించదగిన FastAPI అప్లికేషన్‌లను నిర్మించవచ్చు.
ఇప్పుడు మీ వంతు వచ్చింది. మీ తదుపరి FastAPI ప్రాజెక్ట్‌లో అనుకూల మిడిల్‌వేర్‌ను ఏకీకృతం చేయడం ప్రారంభించండి మరియు మీ API రూపకల్పనలో కొత్త స్థాయి నియంత్రణ మరియు సొగసును అన్‌లాక్ చేయండి. అవకాశాలు చాలా ఉన్నాయి మరియు ఈ లక్షణాన్ని నేర్చుకోవడం వలన మీరు మరింత ప్రభావవంతమైన మరియు సమర్థవంతమైన డెవలపర్‌గా మారతారు.